תכנות בC קבצים מצב פתיחת הקובץ שם תיקני במערכת הפעלה. אם הקובץ לא נמצא במיקום בו אני מריץ את התוכנית יש להוסיף מיקומו בדיסק. פתיחת הקובץ לקריאה:

Transcription

1 תכנות בC קבצים מהו קובץ? תשובה: אוסף של תווים )במקרה שלנו( ששמור על דיסק כלשהו. מוטיבציה: עד עכשיו )ללא קבצים( ברגע שנסגור את התוכנית, כל המידע שהיה לנו בזיכרון נעלם, ובפעם הבאה שמריצים את התוכנית- הכל מתחיל מחדש. למשל: מה היה קורה אם היינו כותבים תוכנית ספר טלפונים אישי ללא שימוש בקבצים? ע"מ להתייחס לקבצים, אנו נעבוד עם משתנים מטיפוס מצביע לקובץ )* )FILE המוגדר ב- stdi.h. כמו כן, פונקציות הספרייה שבהן נשתמש לביצוע פעולות על קבצים )נקראות )File manipulatin functins מוגדרות ב- stdi.h. פתיחה וסגירה של קובץ: לפני שמתחילים להשתמש בקובץ יש "לפתוח" אותו ולהגדיר באיזה אופן נשתמש בו. פתיחה תבוצע באמצעות הפקודה הבאה: FILE* fpen( char*, char* ); מצב פתיחת הקובץ שם הקובץ ומיקומו fp=fpen("c:\\filename.txt","r") דוגמא: שם הקובץ ומיקומו: שם תיקני במערכת הפעלה. אם הקובץ לא נמצא במיקום בו אני מריץ את התוכנית יש להוסיף מיקומו בדיסק. מצב פתיחת הקובץ: פתיחת הקובץ לקריאה: "r" אם הכול תקין יחזיר את הכתובת של הקובץ )מצביע מסוג.(FILE* במקרה של תקלה בפתיחת הקובץ )שם לא תקין, אין הרשאה לקובץ, אין הרשאה לכונן ועוד( הפונקציה תחזיר.NULL "w" פתיחת הקובץ לכתיבה: אם הקובץ לא קיים יוצרת את הקובץ והנתיב ומחזירה את הכתובת של הקובץ )מצביע מסוג.(FILE* אם הקובץ קיים כל מה שהיה בו נמחק ומתחילים לכתוב מחדש, מחזירה את הכתובת של הקובץ )מצביע מסוג.(FILE* במקרה של תקלה בפתיחת הקובץ )אין הרשאה לקובץ, אין הרשאה לכונן ועוד( הפונקציה תחזיר.NULL "a" פתיחת הקובץ לצורך הוספה )לקובץ קיים(:

2 אם הקובץ קיים מוסיפים לקובץ בסופו. מחזירה את הכתובת של הקובץ כאשר סמן הכתיבה בסופו )מצביע מסוג.(FILE* אם הקובץ לא קיים יוצרת את הקובץ והנתיב ומחזירה את הכתובת של הקובץ )מצביע מסוג.(FILE* במקרה של תקלה בפתיחת הקובץ )אין הרשאה לקובץ, אין הרשאה לכונן ועוד( הפונקציה תחזיר.NULL בתום השימוש יש "לסגור" את הקובץ. int fclse( FILE* ); מצביע לקובץ fclse(fp); דוגמא: אם סגר את הקובץ והכול תקין מחזיר 0. אם לא הצליח לסגור את הקובץ מחזיר.EOF כאשר מבצעים פעולות קריאה או כתיבה על קובץ, המערכת שומרת את המקום בו התבצעה הפעולה האחרונה, על מנת לבצע את הפעולה הבאה במקום הבא. למשל: כתבנו 20 תווים לקובץ חדש, התו הבא שנכתוב לקובץ יכנס אוטומטית למקום ה- 21. ניתן "ללכת אחורה" בקובץ, אך בקורס זה לא נלמד כיצד עושים זאת, לכן אם נרצה לעשות זאת, נסגור את הקובץ ונפתח אותו מחדש לקריאה )ואז נתחיל מתחילתו ונוכל להתקדם עד לאן שנרצה( או נשתמש בפקודה.rewind ניסיון לבצע קריאה מתוך קובץ כאשר אנחנו נמצאים בסופו יחזיר את הערך המיוחד )1-(. EOF זהו אינו תו בקובץ אלה ערך החזרה מיוחד בו נוכל להשתמש כדי לדעת שקראנו את כל התוכן. חזרה לתחילת הקובץ: vid rewind(file*); מחזיר את הסמן קריאה \ כתיבה לתחילת הקובץ.

3 פונקציות לקריאה מקובץ: int fscanf(file *fp,char *fmt,address list...); fp מצביע לקובץ )פתוח לקריאה(. - fmt הינה מחרוזת המגדירה כיצד על fscanf לקרוא את הקלט. address list הכתובות של המשתנים שבתוכם fscanf יציב את הקלט. הפונקציה מחזירה את מספר הכתובות שאליהן הכניסה ערכים. פועל ע"פ חוקי.scanf מחזיר )1-( EOF בסוף הקובץ. int fgetc(file *fp); קורא תו אחד מהקובץ שמוצבע ע"י fp בסוף הקובץ יחזיר.EOF מחזיר int אך משתמשים רק ב byte הראשון שלו. char* fgets(char *str,int n,file* fp); קורא מחרוזת מהקובץ שמוצבע ע"י fp ומעביר את המחרוזת ל.str קורא מחרוזת בגודל 1-n או עד ה 'n\' הראשון )קורא גם אותו(. שם '0\' בסוף המחרוזת. אם הקריאה הצליחה מחזיר את str אחרת במצב של שגיאה מחזיר.NULL פונקציות כתיבה לקובץ: int fprintf(file *fp,char *fmt,expressins list...); - fp מצביע לקובץ )פתוח לכתיבה(..fprintf מחרוזת התבנית לפלט עבור ה - fmt expressins list שמות המשתנים שערכיהם יהיו הפלט עבור מחזרות התבנית שהוגדרה. int fputc(int ch, FILE *fp); כותבת את התו ch לתוך הקובץ המוצבע ע"י fp )הפתוח לכתיבה(. אם הפונקציה הצליחה לכתוב את התו היא מחזירה את התו שנכתב, אחרת מחזירה.EOF char fputs(char *str,file *fp); כותבת את המחזרות המוצבעת ע"י str לתוך הקובץ המוצבע ע"י fp )הפתוח לכתיבה(. אם הפונקציה הצליחה היא מחזירה מספר לא שלילי, אחרת מחזירה.EOF

4 פונקציות לניהול קבצים: int remve(char *filename); מחיקת קובץ: הפונקציה מוחקת את הקובץ ששמו מוצבע ע"י.fileName הקובץ חייב שלא להיות פתוח. אם הפונקציה הצליחה אז היא מחזירה 0. אם הקובץ לא קיים או פתוח לקריאה בלבד או ארעה שגיאה אז הפונקציה תחזיר ערך שונה מאפס. שינוי שם של קובץ: int rename(char *ldname, char *newname); הפונקציה משנה את השם של הקובץ מ ldname ל.newName שני השמות חייבים להתייחס לאותו כונן דיסקים. הפונקציה מחזירה 0 אם הצליחה או ערך שונה מ 0 אם קרתה שגיאה. מחרוזות המרה: %5d בקלט יקלוט עד 5 ספרות. בפלט יוסיף רווחים משמאל כדי להשלים ל 5 תווים. %-5d בפלט בלבד - יוסיף רווחים מימין כדי להשלים ל 5 תווים. %10.2f בפלט בלבד - יעגל את הספרות מימין לנק' עד כדי 2 ספרות. %[$!=?] %[a-za-z] יקלוט עד אשר יתקל באחד מהתווים השונים מהתווים בסוגריים. %[^$!=?] יקלוט עד אשר יתקל באחד מהתווים השווים לתווים בסוגריים. %*c יתעלם מה- char בזמן הקלט. כלומר יקרא אותו אך לא יאחסן אותו בתוך משתנה. )בהתאמה ניתן גם לבצע עם שאר הטיפוסים(.

5 תרגילים תרגיל 1 יצירת קובץ, כתיבה לקובץ, קריאה מקובץ רשום טבלת מעקב עבור התכנית הבאה: vid main() { FILE *fp; char str[100]; int res,num; fp=fpen("testfile.txt","w"); if (!fp) exit(1); fprintf(fp,"test"); fclse(fp); fp=fpen("testfile.txt","a"); fprintf(fp," file"); fclse(fp); fp=fpen("testfile.txt","w"); fprintf(fp,"linea 10 ten\n"); fprintf(fp,"lineb 20 twenty\n"); fprintf(fp,"linec 30 thirty\n"); fclse(fp); fp=fpen("testfile.txt","r"); res=fscanf(fp,"%s%d",str,&num); // line #1 // str=linea num=10 res=2 res=fscanf(fp,"%d%s",&num,str); // 2 // res=0 res=fscanf(fp,"%2s%*1s",str); // 3 // str=te res=1 res=fscanf(fp,"%*c"); // 4 // res=0 res=fscanf(fp,"%8s%1d",str,&num); // 5 // str=lineb num=2 res=2 res=fscanf(fp,"%[^\n]%*c",str); // 6 // str=0 twenty res=1 res=fscanf(fp,"%8[^$]%*c",str); // 7 // str=linec 30 res=1 res=fscanf(fp,"%*[^\n]%*c"); // 8 // res=0 res=fscanf(fp,"%d",&num); // 9 // res=-1=eof fclse(fp);

6 תרגיל 2 מה עושה התכנית הבאה? vid main() { FILE *fp; char ch,st[4]; if (!(fp=fpen("testfile.txt","r"))) exit(1); while (fscanf(fp,"%c",&ch)!=eof) printf("%c",ch); rewind(fp); while (fgets(st,4,fp)!=null) printf("%s",st); fclse(fp); rename("testfile.txt"," testfile2.txt"); remve("testfile2.txt"); תרגיל 3 0 כתוב פונקציה אשר מקבלת שני שמות של קבצים ומחזירה 1 שונים או 1- אם הייתה שגיאה בפתיחת קובץ. הקבצים אם זהים, אם הם

7 #include <stdi.h> #include <string.h> תשובה: int diff(char* fname1,char* fname2) { FILE *f1, *f2; char c1,c2,c1readok,c2readok; f1= fpen(fname1,"r"); f2= fpen(fname2,"r"); if(!f1!f2) return -1; d{ c1readok = fscanf(f1,"%c",&c1); c2readok = fscanf(f2,"%c",&c2); while (c1readok==1 && c2readok==1 && c1==c2); fclse (f1); fclse (f2); return (c1==c2 && c1readok==eof && c2readok==eof); vid main () { int ans; ans=diff("1.txt","2.txt"); if (ans==-1) printf("errr penning files\n"); else if (ans==1) printf("identical files\n"); else printf("different files\n "); ניקח תו מכל קובץ, כל עוד אף אחד מהקבצים לא נגמר )כלומר fscanf הצליחה לקרא תו מכל קובץ(, ושני התווים שלקחנו זהים. אם התווים האחרונים היו זהים והגענו לסוף הקובץ בשני הקבצים והקבצים הקבצים זהים ונחזיר 1. אם התווים שונים או שרק אחד מהקבצים נגמר הקבצים שונים ונחזיר 0.

8 תרגיל 4 נתון קובץ נתוני כל הסטודנטים שלומדים בשנה א', בו עבור כל סטודנט מופיעה שורה המכילה: ת.ז, שם פרטי ושם משפחה )עם רווח יחיד ביניהם, באורך של לכל היותר 100 תווים בסה"כ(. בנוסף נתון קובץ ציונים בקורס "תכנות ב- C " אשר בו, עבור כל סטודנט שעשה את הקורס מאז ומעולם, מופיעה שורה המכילה את הת.ז שלו, וציוניו במבחן וב- 6 העבודות. העבודות מהוות 30% מהציון הסופי והמבחן מהווה 70% מהציון הסופי. שני הקבצים הנתונים ממוינים לפי ת.ז, מהקטן )מופיע בשורה הראשונה( לגדול )מופיע בשורה האחרונה(. כתוב פונקציה שתקבל את שמות שני הקבצים הנ"ל, ותדפיס לקובץ פלט שיקרא ut.txt את שמותיהם והציון הסופי של כל הסטודנטים משנה א' שעשו את הקורס. אין לעבור על קובץ יותר מפעם אחת, ואין להכניס למבנה נתונים כלשהו )כגון מערך או רשימה מקושרת(. כמו כן, על הפלט להיות ממוין לפי מס' ת.ז. לדוגמא: shana-aleph.txt c.txt ut.txt 1234 Mshe Chen 1345 Dina Levi 2345 Eli Israeli 4567 Avi Tal Mshe Chen Eli Israeli Avi Tal לא שייך לשנה א' לא עשתה את הקורס תשובה: אלגוריתם )קוד בעמוד הבא(: 1. קרא שורה שלמה משני הקבצים )c ו- shana-aleph ( 2. אם ה- id שנקראה מ- c id == שנקראה מ- shana-aleph : חשב ציון סופי, כתוב שם וציון סופי לקובץ הפלט. קרא שורה שלמה משני הקבצים. חזור ל אחרת, אם ה- id שנקראה מ- c id < שנקראה מ- shana-aleph : קרא שורה שלמה מקובץ c. חזור ל אחרת )אם ה- id שנקראה מ- c id > שנקראה מ- shana-aleph (: קרא שורה שלמה מקובץ.shana-aleph חזור ל בצע כל עוד שני הקבצים לא הסתיימו.

9 #include <stdi.h> #include <string.h> vid calcfinalgrades(char* filenamesa, char* filenamec); vid main() { calcfinalgrades("shana-aleph.txt","c.txt"); vid calcfinalgrades(char* filenamesa, char* filenamec) { // sa = shana-aleph FILE *fsa,*fc,*fout; int idsa,idc,testc,avdtc[6],ksa,kc; char namesa[100]; flat avg; fsa = fpen(filenamesa,"r"); fc = fpen(filenamec,"r"); fout = fpen("ut.txt","w"); if(!fsa!fc!fout) { printf("errr pening file. Exiting."); return; // reading first line frm bth files ksa = fscanf(fsa,"%d %[^\n]%*c",&idsa,namesa); kc = fscanf(fc,"%d %d",&idc,&testc); fr (i=0;i<6;i++) kc = fscanf(fc,"%d",&avdtc[i]); fscanf(fc,"%*c"); // while bth files did nt reach the end while(ksa!=eof && kc!=eof) { // if IDs are equal if (idsa==idc) { // calc & print average avg=0; fr (i=0;i<6;i++) avg+=avdtc[i]; avg=(avg/6)*0.3 + testc*0.7; fprintf(fout,"%s %.2f\n",nameSA,avg); // prgress in bth files ksa = fscanf(fsa,"%d %[^\n]%*c",&idsa,namesa); kc = fscanf(fc,"%d %d",&idc,&testc); fr (i=0;i<6;i++) kc = fscanf(fc,"%d",&avdtc[i]); fscanf(fc,"%*c"); cntinue; // if first id is smaller than the secnd if (idsa<idc) { // prgress in the first file ksa = fscanf(fsa,"%d %[^\n]%*c",&idsa,namesa); cntinue;

10 // if secnd id is smaller than the first if (idsa>idc) { // prgress in the secnd file kc = fscanf(fc,"%d %d",&idc,&testc); fr (i=0;i<6;i++) kc = fscanf(fc,"%d",&avdtc[i]); fscanf(fc,"%*c"); cntinue; // while fclse(fsa); fclse(fc); fclse(fout); תרגיל ( 5 ipc082b ) : להעברת מחסנים של מפעל ייצור גדול הוזמנו 10 משאיות. על מנת לבטח את תהליך ההעברה, חושבה עלות הביטוח ביחס לעלות הפריטים במשאית. כל פריט שייך לאחת מ- 3 קטגוריות - 0, 1 או - 2 כשלכל אחת תעריף ביטוח אחר: בקטגוריה 0 התעריף הוא 2% מערך הפריט, בקטגוריה 1 התעריף הוא 7% מערך הפריט, ובקטגוריה 2 התעריף הוא 15% מערך הפריט. לכל משאית נרשם קובץ ובו רשומים הפריטים שהועמסו עליה. כל קובץ מכיל שורה לכל פריט שנמצא במשאית לפי הפירוט הבא: 5 ספרות 4 ספרות 25 תווים מק"ט כמות הערה למוביל הקובץ ממוין לפי מק"ט בסדר עולה. ייתכנו מספר שורות לכל פריט )בין הקבצים, לא בתוך קובץ אחד(. כמו כן קיים קובץ שהוא קטלוג הפריטים ובו שורה לכל פריט לפי הפרוט הבא: 5 ספרות תו אחד ( '1','2' '0', ) 6 ספרות מק"ט קטגוריה מחיר הפריט הקובץ ממוין לפי מק"ט בסדר עולה. לפני הנסיעה ביקש מנהל המפעל להפיק קובץ לכל קטגוריה ובו ירשמו הפריטים המובלים מאותה קטגוריה. כל קובץ יכיל שורה לכל פריט לפי הפירוט הבא: 5 ספרות 5 ספרות 6 ספרות 5 ספרות ועוד 2 ספרות דיוק )XX.XXXXX( מק"ט כמות מחיר עלות הביטוח

11 הקובץ ימויין לפי מק"ט בסדר עולה. הנתונים בכל שורה יופרדו בפסיק. פריט שלא קיים באף משאית לא יופיע באף קטגוריה. כתוב פונקציה: vid insure (FILE* fvan[10], FILE *fitem, char* name[3]) שמקבלת מערך fvan של מצביעים לקבצים שנרשמו למשאיות, fitem מצביע לקובץ הפריטים, ו- name מערך של שלוש מחרוזות שהן שמות קבצי הסיכום שהפונקציה יוצרת לקטגוריה. 2 1, 0, במערך fvan האיבר הראשון מתייחס למשאית מס' 1 האיבר השני למשאית מס' 2 וכך הלאה. הגבלות: אין לקרוא קובץ יותר מפעם אחת. אין להעתיק קובץ למבנה נתונים אחר )מערך, רשימה משורשרת, קובץ עזר, עץ...( אלגוריתם )קוד בעמוד הבא(: לקרוא שורה שלמה מכל קבצי המשאיות, לתוך מערך part[] ןמערך.quant[] למצוא במערך part[] את מספר החלק הקטן ביותר.)minPart( לקרוא שורות בקובץ הקטלוג עד שמגיעים לשורה שמכילה את פרטי החלק שמספרו.minPart לסכום את כל הכמויות של minpart מכל קבצי המשאיות שבהם הוא מופיע. לחשב עלות כוללת )כמות כללית כפול עלות ליחידה( ולחשב עלות ביטוח )עלות כוללת כפול תעריף ביטוח(. להדפיס את הנתונים הדרושים לקובץ הקטגוריה הרלוונטי. לקרוא שורה נוספת מכל קבצי המשאיות שהכילו את החלק.minPart לחזור ל- 2, ולבצע שוב עד שמסתיימים כל קבצי המשאיות

12 vid insure (FILE* fvan[10],file *fitem, char* name[3]) { FILE *res3[3]; int part1[10],quant1[10],part2,cat2,price2,ttalquant3; int i,flag1[10],flag2,minpart,minidx; flat insurance[3]={0.02,0.07,0.15; // create 3 utput files fr (i=0;i<3;i++) { res3[i]=fpen(name[i],"w"); if (!res3[i]) exit(1); ); // read first lines frm all files fr (i=0;i<10;i++) (1) flag1[i]=fscanf(fvan[i],"%5d%4d%*[^\n]%*c",&part1[i],&quant1[i] (2) flag2=fscanf(f_item,"%5d%1d%6d%*c",&part2,&cat2,&price2); // lp until all van files are finished while (1) { // find minimal part id & its van index minidx=-1; fr (i=0;i<10;i++) if (flag1[i]!=eof && (minidx==-1 part1[i]<minpart)) { minpart=part1[i]; minidx=i; // if nthing was fund - all files are dne, then quit if (minidx==-1) break; // find the part in the items catalg file while (minpart!=part2) (2) quantity // lp all vans, and if a van cntains the part, sum its ttalquant3=0; fr (i=0;i<10;i++) if (part1[i]==minpart) ttalquant3+=quant1[i]; // print t the relevant utput file fprintf(res3[cat2],"%5d%5d%6d%8.5f\n",minpart, ttalquant3, price2*ttalquant3, insurance[cat2]*price2*ttalquant3); the part // read a new line frm all vans files that did cntain fr (i=0;i<10;i++) if (part1[i]==minpart) (1) fr (i=0;i<3;i++) fclse(res[i]);